/* eslint indent: ["off"] */
/* eslint space-before-function-paren: ["off"] */

// 引入 lodash 库，用于数据处理和操作
const _ = require('lodash')
// 引入 await-to-js 库，用于处理异步操作
const { to } = require('await-to-js')
// 引入 moment 库，用于日期和时间操作
const moment = require('moment')
// 引入 fs 模块，用于文件系统操作
const fs = require('fs')
// 引入 fs.promises 模块，用于文件系统操作
const fsPromises = require('fs').promises
// 引入 path 模块，用于处理文件和目录路径
const path = require('path')
// 引入 esm 库，用于在 Node.js 中支持 ES6 模块
const esm = require('esm')
// 使用 esm 配置来加载模块
const requireModule = esm(module)

// 引入 mysql2 库，用于连接 MySQL 数据库
const mysql = require('mysql2')

// 设置 MySQL 数据库连接配置
const dbConfig = {
  host: 'localhost',
  user: 'root',
  password: 'root', // rfy mengxiang55 jjy root
  database: 'macau',
  waitForConnections: true,
  connectionLimit: 50, // 最大连接数 mac: 50, jjy: 100
  connectTimeout: 10000 // 连接超时时间，单位毫秒
}

const { region } = requireModule(path.join(__dirname, '../src/utils/modules/settings.js'))

// 业务类型
const businessType = region === 'm' ? 'macau' : 'hongkong'

// 创建 MySQL 连接池
const pool = mysql.createPool(dbConfig).promise()

// 创建 MySQL 单一连接
const connection = mysql.createConnection(dbConfig)

// 获取项目根目录
const ROOT_DIR = path.join(__dirname, '..')
// helpers 目录
const HELPERS_DIR = path.join(ROOT_DIR, 'helpers')

const { initDatabase, safeInitDatabase } = require(path.join(HELPERS_DIR, 'initDatabase.js'))

// 读取并构建 fixedGroupMapObject
const { finalGroupMap, flatGroupMap, groupArray } = requireModule(path.join(HELPERS_DIR, 'readGroup.js'))
// 读取所有数据
let { allValues } = require(path.join(HELPERS_DIR, 'readAllValues.js'))

// allValues = allValues // .slice(0, 20)

// 历史表
const HISTORY_RESULTS_TABLE = businessType + '_history_results'
// 当前组表
const CURRENT_GROUP_INFOS_TABLE = businessType + '_current_group_infos'
// 杀前组表
const GROUP_ACCURACY_TABLE = businessType + '_group_accuracy'
// 杀前组统计表
const DAILY_GROUP_ACCURACY_SUMMARY_TABLE = businessType + '_daily_group_accuracy_summary'

const GROUP_ACCURACY_MAP_FILE = businessType + '_GroupAccuracyMap.json'

// 获取所有历史记录
// const { getAllHistoryResults } = require(path.join(HELPERS_DIR, 'getAllHistoryResults.js'))
// 插入历史记录
const { insertHistoryResults } = require(path.join(HELPERS_DIR, 'insertHistoryResults.js'))
// 插入当前组信息
const { insertCurrentGroupInfos } = require(path.join(HELPERS_DIR, 'insertCurrentGroupInfos.js'))
// 插入杀前组表数据
const { insertGroupAccuracy } = require(path.join(HELPERS_DIR, 'insertGroupAccuracy.js'))
// 插入杀前组统计表数据
const { insertDailyGroupAccuracySummary } = require(path.join(HELPERS_DIR, 'insertDailyGroupAccuracySummary.js'))
// 更新历史表预测等字段数据
const { updateHistoryForecast } = require(path.join(HELPERS_DIR, 'updateHistoryForecast.js'))

// 初始化分组和杀前组映射对象
const { initGroupAccuracyMap } = require(path.join(HELPERS_DIR, 'initGroupAccuracyMap.js'))

const mian = async () => {
  // 初始化数据库
  const [err_01] = await to(safeInitDatabase(connection))
  if (err_01) {
    return
  }
  console.log('数据库初始化完成')

  // 插入历史记录表数据
  const [err_02, historyResults] = await to(insertHistoryResults(pool, allValues, HISTORY_RESULTS_TABLE))
  if (err_02) {
    console.log('历史表插入失败', err_02)
    return
  }
  console.log('历史表完成')

  const startTime = new Date()
  // 插入当前组信息表数据
  const [err_03] = await to(
    insertCurrentGroupInfos(pool, groupArray, flatGroupMap, historyResults, CURRENT_GROUP_INFOS_TABLE)
  )
  if (err_03) {
    console.log('当前组表插入失败', err_03)
    return
  }
  const endTime = new Date()
  console.log(`当前组表, 完成, 用时: ${(endTime - startTime) / 1000} 秒`)

  const startTime2 = new Date()

  // 插入杀前组表数据
  const [err_04] = await to(
    insertGroupAccuracy(pool, flatGroupMap, historyResults, CURRENT_GROUP_INFOS_TABLE, GROUP_ACCURACY_TABLE)
  )
  if (err_04) {
    console.log('杀前组表插入失败', err_04)
    return
  }

  const endTime2 = new Date()
  console.log(`杀前组表, 完成, 用时: ${(endTime2 - startTime2) / 1000} 秒`)

  const startTime3 = new Date()

  // 初始化分组和杀前组映射对象
  const [err_05, groupAccuracyMap] = await to(
    initGroupAccuracyMap(pool, groupArray, GROUP_ACCURACY_TABLE, GROUP_ACCURACY_MAP_FILE)
  )
  if (err_05) {
    console.log('映射对象初始化失败', err_05)
    return
  }
  const endTime3 = new Date()
  console.log(`映射对象, 完成, 用时: ${(endTime3 - startTime3) / 1000} 秒`)

  // 读取分组和杀前组映射对象
  // console.log('groupAccuracyMap', Object.keys(groupAccuracyMap).length)

  const startTime4 = new Date()
  // 插入杀前组统计表数据
  const [err_06] = await to(
    insertDailyGroupAccuracySummary(
      pool,
      groupAccuracyMap,
      historyResults,
      GROUP_ACCURACY_TABLE,
      DAILY_GROUP_ACCURACY_SUMMARY_TABLE
    )
  )
  if (err_06) {
    console.log('杀前组统计表插入失败', err_06)
    return
  }
  const endTime4 = new Date()
  console.log(`杀前组统计表表, 完成, 用时: ${(endTime4 - startTime4) / 1000} 秒`)

  const startTime5 = new Date()

  // 更新历史表预测等字段数据
  const [err_07] = await to(
    updateHistoryForecast(pool, historyResults, DAILY_GROUP_ACCURACY_SUMMARY_TABLE, HISTORY_RESULTS_TABLE)
  )
  if (err_07) {
    console.log('更新历史表失败', err_07)
    return
  }
  const endTime5 = new Date()
  console.log(`更新历史表,完成, 用时: ${(endTime5 - startTime5) / 1000} 秒`)
}

mian()
